package com.aa.base

import android.content.Context
import android.text.format.DateUtils
import java.math.BigDecimal
import java.text.ParseException
import java.text.SimpleDateFormat
import java.util.*

/**
 * 时间相关的工具类
 */
object BaseBatteryHelpers {
    /**
     * 毫秒与毫秒的倍数
     */
    const val MSEC = 1

    /**
     * 秒与毫秒的倍数
     */
    const val SEC = 1000
    /******************** 时间相关常量  */
    /**
     * 分与毫秒的倍数
     */
    const val MIN = 60000

    /**
     * 时与毫秒的倍数
     */
    const val HOUR = 3600000

    /**
     * 天与毫秒的倍数
     */
    const val DAY = 86400000

    /**
     *
     * 在工具类中经常使用到工具类的格式化描述，这个主要是一个日期的操作类，所以日志格式主要使用 SimpleDateFormat的定义格式.
     * 格式的意义如下： 日期和时间模式 <br></br>
     *
     * 日期和时间格式由日期和时间模式字符串指定。在日期和时间模式字符串中，未加引号的字母 'A' 到 'Z' 和 'a' 到 'z'
     * 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来，以免进行解释。"''"
     * 表示单引号。所有其他字符均不解释；只是在格式化时将它们简单复制到输出字符串，或者在分析时与输入字符串进行匹配。
     *
     * 定义了以下模式字母（所有其他字符 'A' 到 'Z' 和 'a' 到 'z' 都被保留）： <br></br>
     * <table border="1" cellspacing="1" cellpadding="1" summary="Chart shows pattern letters, date/time component, presentation, and examples.">
     * <tr bgcolor="#ccccff">
     * <th align="left">字母</th>
     * <th align="left">日期或时间元素</th>
     * <th align="left">表示</th>
     * <th align="left">示例</th>
    </tr> *
     * <tr>
     * <td>`G`</td>
     * <td>Era 标志符</td>
     * <td>Text</td>
     * <td>`AD`</td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`y` </td>
     * <td>年 </td>
     * <td>Year </td>
     * <td>`1996`; `96` </td>
    </tr> *
     * <tr>
     * <td>`M` </td>
     * <td>年中的月份 </td>
     * <td>Month </td>
     * <td>`July`; `Jul`; `07` </td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`w` </td>
     * <td>年中的周数 </td>
     * <td>Number </td>
     * <td>`27` </td>
    </tr> *
     * <tr>
     * <td>`W` </td>
     * <td>月份中的周数 </td>
     * <td>Number </td>
     * <td>`2` </td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`D` </td>
     * <td>年中的天数 </td>
     * <td>Number </td>
     * <td>`189` </td>
    </tr> *
     * <tr>
     * <td>`d` </td>
     * <td>月份中的天数 </td>
     * <td>Number </td>
     * <td>`10` </td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`F` </td>
     * <td>月份中的星期 </td>
     * <td>Number </td>
     * <td>`2` </td>
    </tr> *
     * <tr>
     * <td>`E` </td>
     * <td>星期中的天数 </td>
     * <td>Text </td>
     * <td>`Tuesday`; `Tue` </td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`a` </td>
     * <td>Am/pm 标记 </td>
     * <td>Text </td>
     * <td>`PM` </td>
    </tr> *
     * <tr>
     * <td>`H` </td>
     * <td>一天中的小时数（0-23） </td>
     * <td>Number </td>
     * <td>`0` </td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`k` </td>
     * <td>一天中的小时数（1-24） </td>
     * <td>Number </td>
     * <td>`24` </td>
    </tr> *
     * <tr>
     * <td>`K` </td>
     * <td>am/pm 中的小时数（0-11） </td>
     * <td>Number </td>
     * <td>`0` </td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`h` </td>
     * <td>am/pm 中的小时数（1-12） </td>
     * <td>Number </td>
     * <td>`12` </td>
    </tr> *
     * <tr>
     * <td>`m` </td>
     * <td>小时中的分钟数 </td>
     * <td>Number </td>
     * <td>`30` </td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`s` </td>
     * <td>分钟中的秒数 </td>
     * <td>Number </td>
     * <td>`55` </td>
    </tr> *
     * <tr>
     * <td>`S` </td>
     * <td>毫秒数 </td>
     * <td>Number </td>
     * <td>`978` </td>
    </tr> *
     * <tr bgcolor="#eeeeff">
     * <td>`z` </td>
     * <td>时区 </td>
     * <td>General time zone </td>
     * <td>`Pacific Standard Time`; `PST`; `GMT-08:00` </td>
    </tr> *
     * <tr>
     * <td>`Z` </td>
     * <td>时区 </td>
     * <td>RFC 822 time zone </td>
     * <td>`-0800` </td>
    </tr> *
    </table> *
     * <pre>
     * HH:mm    15:44
     * h:mm a    3:44 下午
     * HH:mm z    15:44 CST
     * HH:mm Z    15:44 +0800
     * HH:mm zzzz    15:44 中国标准时间
     * HH:mm:ss    15:44:40
     * yyyy-MM-dd    2016-08-12
     * yyyy-MM-dd HH:mm    2016-08-12 15:44
     * yyyy-MM-dd HH:mm:ss    2016-08-12 15:44:40
     * yyyy-MM-dd HH:mm:ss zzzz    2016-08-12 15:44:40 中国标准时间
     * EEEE yyyy-MM-dd HH:mm:ss zzzz    星期五 2016-08-12 15:44:40 中国标准时间
     * yyyy-MM-dd HH:mm:ss.SSSZ    2016-08-12 15:44:40.461+0800
     * yyyy-MM-dd'T'HH:mm:ss.SSSZ    2016-08-12T15:44:40.461+0800
     * yyyy.MM.dd G 'at' HH:mm:ss z    2016.08.12 公元 at 15:44:40 CST
     * K:mm a    3:44 下午
     * EEE, MMM d, ''yy    星期五, 八月 12, '16
     * hh 'o''clock' a, zzzz    03 o'clock 下午, 中国标准时间
     * yyyyy.MMMMM.dd GGG hh:mm aaa    02016.八月.12 公元 03:44 下午
     * EEE, d MMM yyyy HH:mm:ss Z    星期五, 12 八月 2016 15:44:40 +0800
     * yyMMddHHmmssZ    160812154440+0800
     * yyyy-MM-dd'T'HH:mm:ss.SSSZ    2016-08-12T15:44:40.461+0800
     * EEEE 'DATE('yyyy-MM-dd')' 'TIME('HH:mm:ss')' zzzz    星期五 DATE(2016-08-12) TIME(15:44:40) 中国标准时间
    </pre> *
     */
    val DEFAULT_SDF =
        SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())

    /**
     * Flags used with [DateUtils.formatDateRange].
     */
    private const val TIME_FLAGS = (DateUtils.FORMAT_SHOW_TIME
            or DateUtils.FORMAT_SHOW_DATE)
    /**
     * 将时间戳转为时间字符串
     *
     * 格式为用户自定义
     *
     * @param milliseconds 毫秒时间戳
     * @param format       时间格式
     * @return 时间字符串
     */
    /**
     * 将时间戳转为时间字符串
     *
     * 格式为yyyy-MM-dd HH:mm:ss
     *
     * @param milliseconds 毫秒时间戳
     * @return 时间字符串
     */
    @JvmOverloads
    fun milliseconds2String(
        milliseconds: Long,
        format: SimpleDateFormat = DEFAULT_SDF
    ): String {
        return format.format(Date(milliseconds))
    }
    /**
     * 将时间字符串转为时间戳
     *
     * 格式为用户自定义
     *
     * @param time   时间字符串
     * @param format 时间格式
     * @return 毫秒时间戳
     */
    /**
     * 将时间字符串转为时间戳
     *
     * 格式为yyyy-MM-dd HH:mm:ss
     *
     * @param time 时间字符串
     * @return 毫秒时间戳
     */
    @JvmOverloads
    fun string2Milliseconds(
        time: String?,
        format: SimpleDateFormat = DEFAULT_SDF
    ): Long {
        try {
            return format.parse(time).time
        } catch (e: ParseException) {
            e.printStackTrace()
        }
        return -1
    }
    /**
     * 将时间字符串转为Date类型
     *
     * 格式为用户自定义
     *
     * @param time   时间字符串
     * @param format 时间格式
     * @return Date类型
     */
    /**
     * 将时间字符串转为Date类型
     *
     * 格式为yyyy-MM-dd HH:mm:ss
     *
     * @param time 时间字符串
     * @return Date类型
     */
    @JvmOverloads
    fun string2Date(
        time: String?,
        format: SimpleDateFormat = DEFAULT_SDF
    ): Date {
        return Date(
            string2Milliseconds(
                time,
                format
            )
        )
    }
    /**
     * 将Date类型转为时间字符串
     *
     * 格式为用户自定义
     *
     * @param time   Date类型时间
     * @param format 时间格式
     * @return 时间字符串
     */
    /**
     * 将Date类型转为时间字符串
     *
     * 格式为yyyy-MM-dd HH:mm:ss
     *
     * @param time Date类型时间
     * @return 时间字符串
     */
    @JvmOverloads
    fun date2String(
        time: Date?,
        format: SimpleDateFormat = DEFAULT_SDF
    ): String {
        return format.format(time)
    }

    /**
     * 将Date类型转为时间戳
     *
     * @param time Date类型时间
     * @return 毫秒时间戳
     */
    fun date2Milliseconds(time: Date): Long {
        return time.time
    }

    /**
     * 将时间戳转为Date类型
     *
     * @param milliseconds 毫秒时间戳
     * @return Date类型时间
     */
    fun milliseconds2Date(milliseconds: Long): Date {
        return Date(milliseconds)
    }

    /**
     * 毫秒时间戳单位转换（单位：unit）
     *
     * @param milliseconds 毫秒时间戳
     * @param unit
     *  * MSEC:毫秒
     *  * SEC :秒
     *  * MIN :分
     *  * HOUR:小时
     *  * DAY :天
     *
     * @return unit时间戳
     */
    private fun milliseconds2Unit(milliseconds: Long, unit: Int): Long {
        when (unit) {
            MSEC, SEC, MIN, HOUR, DAY -> return milliseconds / unit
        }
        return -1
    }

    /**
     * 获取两个时间差（单位：unit）
     *
     * time1和time2格式都为yyyy-MM-dd HH:mm:ss
     *
     * @param time0 时间字符串1
     * @param time1 时间字符串2
     * @param unit
     *  * MSEC:毫秒
     *  * SEC :秒
     *  * MIN :分
     *  * HOUR:小时
     *  * DAY :天
     *
     * @return unit时间戳
     */
    fun getIntervalTime(time0: String?, time1: String?, unit: Int): Long {
        return getIntervalTime(
            time0,
            time1,
            unit,
            DEFAULT_SDF
        )
    }

    /**
     * 获取两个时间差（单位：unit）
     *
     * time1和time2格式都为format
     *
     * @param time0  时间字符串1
     * @param time1  时间字符串2
     * @param unit
     *  * MSEC:毫秒
     *  * SEC :秒
     *  * MIN :分
     *  * HOUR:小时
     *  * DAY :天
     *
     * @param format 时间格式
     * @return unit时间戳
     */
    fun getIntervalTime(
        time0: String?,
        time1: String?,
        unit: Int,
        format: SimpleDateFormat
    ): Long {
        return Math.abs(
            milliseconds2Unit(
                string2Milliseconds(
                    time0,
                    format
                )
                        - string2Milliseconds(
                    time1,
                    format
                ), unit
            )
        )
    }

    /**
     * 获取两个时间差（单位：unit）
     *
     * time1和time2都为Date类型
     *
     * @param time0 Date类型时间1
     * @param time1 Date类型时间2
     * @param unit
     *  * MSEC:毫秒
     *  * SEC :秒
     *  * MIN :分
     *  * HOUR:小时
     *  * DAY :天
     *
     * @return unit时间戳
     */
    fun getIntervalTime(time0: Date, time1: Date, unit: Int): Long {
        return Math.abs(
            milliseconds2Unit(
                date2Milliseconds(
                    time1
                )
                        - date2Milliseconds(
                    time0
                ), unit
            )
        )
    }

    /**
     * Format and return the given time interval use default timezone.
     */
    fun formatIntervalTimeString(
        intervalStart: Long, intervalEnd: Long,
        recycle: StringBuilder?, context: Context?
    ): String {
        var recycle = recycle
        if (recycle == null) {
            recycle = StringBuilder()
        } else {
            recycle.setLength(0)
        }
        val formatter = Formatter(recycle)
        return DateUtils.formatDateRange(
            context,
            formatter,
            intervalStart,
            intervalEnd,
            TIME_FLAGS,
            TimeZone.getDefault().id
        ).toString()
    }

    /**
     * 获取当前时间
     *
     * @return 毫秒时间戳
     */
    val curTimeMills: Long
        get() = System.currentTimeMillis()

    /**
     * 获取当前时间
     *
     * 格式为yyyy-MM-dd HH:mm:ss
     *
     * @return 时间字符串
     */
    val curTimeString: String
        get() = date2String(Date())

    /**
     * 获取当前时间
     *
     * 格式为用户自定义
     *
     * @param format 时间格式
     * @return 时间字符串
     */
    fun getCurTimeString(format: SimpleDateFormat): String {
        return date2String(
            Date(),
            format
        )
    }

    /**
     * 获取当前时间
     *
     * Date类型
     *
     * @return Date类型时间
     */
    val curTimeDate: Date
        get() = Date()

    /**
     * 获取与当前时间的差（单位：unit）
     *
     * time格式为yyyy-MM-dd HH:mm:ss
     *
     * @param time 时间字符串
     * @param unit
     *  * MSEC:毫秒
     *  * SEC :秒
     *  * MIN :分
     *  * HOUR:小时
     *  * DAY :天
     *
     * @return unit时间戳
     */
    fun getIntervalByNow(time: String?, unit: Int): Long {
        return getIntervalByNow(
            time,
            unit,
            DEFAULT_SDF
        )
    }

    /**
     * 获取与当前时间的差（单位：unit）
     *
     * time格式为format
     *
     * @param time   时间字符串
     * @param unit
     *  * MSEC:毫秒
     *  * SEC :秒
     *  * MIN :分
     *  * HOUR:小时
     *  * DAY :天
     *
     * @param format 时间格式
     * @return unit时间戳
     */
    fun getIntervalByNow(
        time: String?,
        unit: Int,
        format: SimpleDateFormat
    ): Long {
        return getIntervalTime(
            curTimeString,
            time,
            unit,
            format
        )
    }

    /**
     * 获取与当前时间的差（单位：unit）
     *
     * time为Date类型
     *
     * @param time Date类型时间
     * @param unit
     *  * MSEC:毫秒
     *  * SEC :秒
     *  * MIN :分
     *  * HOUR:小时
     *  * DAY :天
     *
     * @return unit时间戳
     */
    fun getIntervalByNow(time: Date, unit: Int): Long {
        return getIntervalTime(
            curTimeDate,
            time,
            unit
        )
    }

    /**
     * 判断闰年
     *
     * @param year 年份
     * @return true: 闰年<br></br>false: 平年
     */
    fun isLeapYear(year: Int): Boolean {
        return year % 4 == 0 && year % 100 != 0 || year % 400 == 0
    }

    fun isEarly(days: Int, time: Long): Boolean {
        return currentTimeMillis() - time > days * 24 * 3600 * 1000
    }

    fun currentTimeSecond(): Int {
        return (System.currentTimeMillis() / 1000).toInt()
    }

    fun currentTimeMillis(): Long {
        return System.currentTimeMillis()
    }

    /**
     * 英国当前时间
     *
     * @return long
     */
    fun currentUkTimeMillis(): Long {
        return System.currentTimeMillis() - TimeZone.getDefault().rawOffset
    }

    val tsTimes: LongArray
        get() {
            val times = LongArray(2)
            val calendar = Calendar.getInstance()
            times[0] = calendar.timeInMillis / 1000
            calendar[Calendar.HOUR_OF_DAY] = 0
            calendar[Calendar.MINUTE] = 0
            calendar[Calendar.SECOND] = 0
            times[1] = calendar.timeInMillis / 1000
            return times
        }

    fun getFormatDatetime(year: Int, month: Int, day: Int): String {
        val formatter = SimpleDateFormat("yyyy-MM-dd")
        return formatter.format(GregorianCalendar(year, month, day).time)
    }

    fun getDateFromFormatString(formatDate: String?): Date? {
        val sdf = SimpleDateFormat("yyyy-MM-dd")
        try {
            return sdf.parse(formatDate)
        } catch (e: ParseException) {
            e.printStackTrace()
        }
        return null
    }

    val nowDatetime: String
        get() {
            val formatter =
                SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
            return formatter.format(Date())
        }

    val now: Int
        get() = (Date().time / 1000).toInt()

    fun getNowDateTime(format: String?): String {
        val date = Date()
        val df =
            SimpleDateFormat(format, Locale.getDefault())
        return df.format(date)
    }

    fun getDateString(milliseconds: Long): String {
        return getDateTimeString(
            milliseconds,
            "yyyyMMdd"
        )
    }

    fun getTimeString(milliseconds: Long): String {
        return getDateTimeString(
            milliseconds,
            "HH:mm:ss"
        )
    }

    fun getBeijingNowTimeString(format: String?): String {
        val timezone = TimeZone.getTimeZone("Asia/Shanghai")
        val date =
            Date(currentTimeMillis())
        val formatter =
            SimpleDateFormat(format, Locale.getDefault())
        formatter.timeZone = timezone
        val gregorianCalendar = GregorianCalendar()
        gregorianCalendar.timeZone = timezone
        val prefix =
            if (gregorianCalendar[Calendar.AM_PM] == Calendar.AM) "上午" else "下午"
        return prefix + formatter.format(date)
    }

    fun getBeijingNowTime(format: String?): String {
        val timezone = TimeZone.getTimeZone("Asia/Shanghai")
        val date =
            Date(currentTimeMillis())
        val formatter =
            SimpleDateFormat(format, Locale.getDefault())
        formatter.timeZone = timezone
        return formatter.format(date)
    }

    fun getDateTimeString(milliseconds: Long, format: String?): String {
        val date = Date(milliseconds)
        val formatter =
            SimpleDateFormat(format, Locale.getDefault())
        return formatter.format(date)
    }

    fun getFavoriteCollectTime(milliseconds: Long): String {
        var showDataString = ""
        val today = Date()
        val date = Date(milliseconds)
        val firstDateThisYear = Date(today.year, 0, 0)
        showDataString = if (!date.before(firstDateThisYear)) {
            val dateformatter =
                SimpleDateFormat("MM-dd", Locale.getDefault())
            dateformatter.format(date)
        } else {
            val dateformatter =
                SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
            dateformatter.format(date)
        }
        return showDataString
    }

    fun getTimeShowString(milliseconds: Long, abbreviate: Boolean): String {
        var dataString = ""
        var timeStringBy24 = ""
        val currentTime = Date(milliseconds)
        val today = Date()
        val todayStart = Calendar.getInstance()
        todayStart[Calendar.HOUR_OF_DAY] = 0
        todayStart[Calendar.MINUTE] = 0
        todayStart[Calendar.SECOND] = 0
        todayStart[Calendar.MILLISECOND] = 0
        val todaybegin = todayStart.time
        val yesterdaybegin = Date(todaybegin.time - 3600 * 24 * 1000)
        val preyesterday =
            Date(yesterdaybegin.time - 3600 * 24 * 1000)
        dataString = if (!currentTime.before(todaybegin)) {
            "今天"
        } else if (!currentTime.before(yesterdaybegin)) {
            "昨天"
        } else if (!currentTime.before(preyesterday)) {
            "前天"
        } else if (isSameWeekDates(
                currentTime,
                today
            )
        ) {
            getWeekOfDate(
                currentTime
            )
        } else {
            val dateformatter =
                SimpleDateFormat("yyyy-MM-dd", Locale.getDefault())
            dateformatter.format(currentTime)
        }
        val timeformatter24 =
            SimpleDateFormat("HH:mm", Locale.getDefault())
        timeStringBy24 = timeformatter24.format(currentTime)
        return if (abbreviate) {
            if (!currentTime.before(todaybegin)) {
                getTodayTimeBucket(
                    currentTime
                )
            } else {
                dataString
            }
        } else {
            "$dataString $timeStringBy24"
        }
    }

    /**
     * 根据不同时间段，显示不同时间
     *
     * @param date
     * @return
     */
    fun getTodayTimeBucket(date: Date?): String {
        val calendar = Calendar.getInstance()
        calendar.time = date
        val timeformatter0to11 =
            SimpleDateFormat("KK:mm", Locale.getDefault())
        val timeformatter1to12 =
            SimpleDateFormat("hh:mm", Locale.getDefault())
        val hour = calendar[Calendar.HOUR_OF_DAY]
        if (hour >= 0 && hour < 5) {
            return "凌晨 " + timeformatter0to11.format(date)
        } else if (hour >= 5 && hour < 12) {
            return "上午 " + timeformatter0to11.format(date)
        } else if (hour >= 12 && hour < 18) {
            return "下午 " + timeformatter1to12.format(date)
        } else if (hour >= 18 && hour < 24) {
            return "晚上 " + timeformatter1to12.format(date)
        }
        return ""
    }

    /**
     * 根据日期获得星期
     *
     * @param date
     * @return
     */
    fun getWeekOfDate(date: Date?): String {
        val weekDaysName =
            arrayOf("星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六")
        // String[] weekDaysCode = { "0", "1", "2", "3", "4", "5", "6" };
        val calendar = Calendar.getInstance()
        calendar.time = date
        val intWeek = calendar[Calendar.DAY_OF_WEEK] - 1
        return weekDaysName[intWeek]
    }

    fun isSameDay(time1: Long, time2: Long): Boolean {
        return isSameDay(
            Date(time1),
            Date(time2)
        )
    }

    fun isSameDay(date1: Date?, date2: Date?): Boolean {
        val cal1 = Calendar.getInstance()
        val cal2 = Calendar.getInstance()
        cal1.time = date1
        cal2.time = date2
        return cal1[Calendar.YEAR] == cal2[Calendar.YEAR] &&
                cal1[Calendar.DAY_OF_YEAR] == cal2[Calendar.DAY_OF_YEAR]
    }

    /**
     * 判断两个日期是否在同一周
     *
     * @param date1
     * @param date2
     * @return
     */
    fun isSameWeekDates(date1: Date?, date2: Date?): Boolean {
        val cal1 = Calendar.getInstance()
        val cal2 = Calendar.getInstance()
        cal1.time = date1
        cal2.time = date2
        val subYear = cal1[Calendar.YEAR] - cal2[Calendar.YEAR]
        if (0 == subYear) {
            if (cal1[Calendar.WEEK_OF_YEAR] == cal2[Calendar.WEEK_OF_YEAR]) return true
        } else if (1 == subYear && 11 == cal2[Calendar.MONTH]) {
            // 如果12月的最后一周横跨来年第一周的话则最后一周即算做来年的第一周
            if (cal1[Calendar.WEEK_OF_YEAR] == cal2[Calendar.WEEK_OF_YEAR]) return true
        } else if (-1 == subYear && 11 == cal1[Calendar.MONTH]) {
            if (cal1[Calendar.WEEK_OF_YEAR] == cal2[Calendar.WEEK_OF_YEAR]) return true
        }
        return false
    }
    fun isSameData(currentTime: Long, lastTime: Long): Boolean {
        try {
            val nowCal = Calendar.getInstance()
            val dataCal = Calendar.getInstance()
            val df1 = SimpleDateFormat("yyyy-MM-dd  HH:mm:ss")
            val df2 = SimpleDateFormat("yyyy-MM-dd  HH:mm:ss")

            val data1 = df1.format(currentTime)
            val data2 = df2.format(lastTime)
            val now = df1.parse(data1)
            val date = df2.parse(data2)
            nowCal.time = now
            dataCal.time = date
            return isSameDay(
                nowCal,
                dataCal
            )
        } catch (e: Exception) {
            e.printStackTrace()
            return false

        }
        return false
    }
    fun isSameDay(cal1: Calendar?, cal2: Calendar?): Boolean {
        return if (cal1 != null && cal2 != null) {
            cal1[Calendar.ERA] === cal2[Calendar.ERA] && cal1[Calendar.YEAR] === cal2[Calendar.YEAR] && cal1[Calendar.DAY_OF_YEAR] === cal2[Calendar.DAY_OF_YEAR]
        } else {
            false
        }
    }


    fun getSecondsByMilliseconds(milliseconds: Long): Long {
        // if (seconds == 0) {
        // seconds = 1;
        // }
        return BigDecimal((milliseconds.toDouble() / 1000.toFloat()))
            .setScale(
                0,
                BigDecimal.ROUND_HALF_UP
            ).intValueExact().toLong()
    }

    fun secToTime(time: Int): String {
        var timeStr: String? = null
        var hour = 0
        var minute = 0
        var second = 0
        if (time <= 0) return "00:00" else {
            minute = time / 60
            if (minute < 60) {
                second = time % 60
                timeStr =
                    unitFormat(
                        minute
                    ) + ":" + unitFormat(
                        second
                    )
            } else {
                hour = minute / 60
                if (hour > 99) return "99:59:59"
                minute = minute % 60
                second = time - hour * 3600 - minute * 60
                timeStr =
                    unitFormat(
                        hour
                    ) + ":" + unitFormat(
                        minute
                    ) + ":" + unitFormat(
                        second
                    )
            }
        }
        return timeStr
    }

    fun unitFormat(i: Int): String {
        var retStr: String? = null
        retStr = if (i >= 0 && i < 10) "0" + Integer.toString(i) else "" + i
        return retStr
    }

    fun getElapseTimeForShow(milliseconds: Int): String {
        val sb = StringBuilder()
        var seconds = milliseconds / 1000
        if (seconds < 1) seconds = 1
        val hour = seconds / (60 * 60)
        if (hour != 0) {
            sb.append(hour).append("小时")
        }
        val minute = (seconds - 60 * 60 * hour) / 60
        if (minute != 0) {
            sb.append(minute).append("分")
        }
        val second = seconds - 60 * 60 * hour - 60 * minute
        if (second != 0) {
            sb.append(second).append("秒")
        }
        return sb.toString()
    }

    fun isSameDayDisplay(
        time1: Long,
        time2: Long,
        context: Context?
    ): Boolean {
        val displayTimeZone = TimeZone.getDefault()
        val cal1 = Calendar.getInstance(displayTimeZone)
        val cal2 = Calendar.getInstance(displayTimeZone)
        cal1.timeInMillis = time1
        cal2.timeInMillis = time2
        return (cal1[Calendar.YEAR] == cal2[Calendar.YEAR]
                && cal1[Calendar.DAY_OF_YEAR] == cal2[Calendar.DAY_OF_YEAR])
    }

    val iso8601TimeString: String
        get() = getIso8601TimeString(
            0
        )

    fun getIso8601TimeString(time: Long): String {
        val sdf =
            SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ", Locale.getDefault())
        val date = Date()
        if (time > 0) {
            date.time = time
        }
        return sdf.format(date)
    }

    fun getIso8601TimeAfterTodayDayString(days: Int): String {
        val date = Date()
        var time = date.time
        time += days * DAY.toLong()
        return getIso8601TimeString(
            time
        )
    }
}